home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / random.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  24KB  |  757 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Random variable generators.
  5.  
  6.     integers
  7.     --------
  8.            uniform within range
  9.  
  10.     sequences
  11.     ---------
  12.            pick random element
  13.            pick random sample
  14.            generate random permutation
  15.  
  16.     distributions on the real line:
  17.     ------------------------------
  18.            uniform
  19.            normal (Gaussian)
  20.            lognormal
  21.            negative exponential
  22.            gamma
  23.            beta
  24.            pareto
  25.            Weibull
  26.  
  27.     distributions on the circle (angles 0 to 2pi)
  28.     ---------------------------------------------
  29.            circular uniform
  30.            von Mises
  31.  
  32. General notes on the underlying Mersenne Twister core generator:
  33.  
  34. * The period is 2**19937-1.
  35. * It is one of the most extensively tested generators in existence
  36. * Without a direct way to compute N steps forward, the
  37.   semantics of jumpahead(n) are weakened to simply jump
  38.   to another distant state and rely on the large period
  39.   to avoid overlapping sequences.
  40. * The random() method is implemented in C, executes in
  41.   a single Python step, and is, therefore, threadsafe.
  42.  
  43. '''
  44. from warnings import warn as _warn
  45. from types import MethodType as _MethodType, BuiltinMethodType as _BuiltinMethodType
  46. from math import log as _log, exp as _exp, pi as _pi, e as _e
  47. from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
  48. from os import urandom as _urandom
  49. from binascii import hexlify as _hexlify
  50. __all__ = [
  51.     'Random',
  52.     'seed',
  53.     'random',
  54.     'uniform',
  55.     'randint',
  56.     'choice',
  57.     'sample',
  58.     'randrange',
  59.     'shuffle',
  60.     'normalvariate',
  61.     'lognormvariate',
  62.     'expovariate',
  63.     'vonmisesvariate',
  64.     'gammavariate',
  65.     'gauss',
  66.     'betavariate',
  67.     'paretovariate',
  68.     'weibullvariate',
  69.     'getstate',
  70.     'setstate',
  71.     'jumpahead',
  72.     'WichmannHill',
  73.     'getrandbits',
  74.     'SystemRandom']
  75. NV_MAGICCONST = 4 * _exp(-0.5) / _sqrt(2.0)
  76. TWOPI = 2.0 * _pi
  77. LOG4 = _log(4.0)
  78. SG_MAGICCONST = 1.0 + _log(4.5)
  79. BPF = 53
  80. RECIP_BPF = 2 ** (-BPF)
  81. import _random
  82.  
  83. class Random(_random.Random):
  84.     """Random number generator base class used by bound module functions.
  85.  
  86.     Used to instantiate instances of Random to get generators that don't
  87.     share state.  Especially useful for multi-threaded programs, creating
  88.     a different instance of Random for each thread, and using the jumpahead()
  89.     method to ensure that the generated sequences seen by each thread don't
  90.     overlap.
  91.  
  92.     Class Random can also be subclassed if you want to use a different basic
  93.     generator of your own devising: in that case, override the following
  94.     methods:  random(), seed(), getstate(), setstate() and jumpahead().
  95.     Optionally, implement a getrandombits() method so that randrange()
  96.     can cover arbitrarily large ranges.
  97.  
  98.     """
  99.     VERSION = 2
  100.     
  101.     def __init__(self, x = None):
  102.         '''Initialize an instance.
  103.  
  104.         Optional argument x controls seeding, as for Random.seed().
  105.         '''
  106.         self.seed(x)
  107.         self.gauss_next = None
  108.  
  109.     
  110.     def seed(self, a = None):
  111.         '''Initialize internal state from hashable object.
  112.  
  113.         None or no argument seeds from current time or from an operating
  114.         system specific randomness source if available.
  115.  
  116.         If a is not None or an int or long, hash(a) is used instead.
  117.         '''
  118.         if a is None:
  119.             
  120.             try:
  121.                 a = long(_hexlify(_urandom(16)), 16)
  122.             except NotImplementedError:
  123.                 import time as time
  124.                 a = long(time.time() * 256)
  125.             except:
  126.                 None<EXCEPTION MATCH>NotImplementedError
  127.             
  128.  
  129.         None<EXCEPTION MATCH>NotImplementedError
  130.         super(Random, self).seed(a)
  131.         self.gauss_next = None
  132.  
  133.     
  134.     def getstate(self):
  135.         '''Return internal state; can be passed to setstate() later.'''
  136.         return (self.VERSION, super(Random, self).getstate(), self.gauss_next)
  137.  
  138.     
  139.     def setstate(self, state):
  140.         '''Restore internal state from object returned by getstate().'''
  141.         version = state[0]
  142.         if version == 2:
  143.             (version, internalstate, self.gauss_next) = state
  144.             super(Random, self).setstate(internalstate)
  145.         else:
  146.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  147.  
  148.     
  149.     def __getstate__(self):
  150.         return self.getstate()
  151.  
  152.     
  153.     def __setstate__(self, state):
  154.         self.setstate(state)
  155.  
  156.     
  157.     def __reduce__(self):
  158.         return (self.__class__, (), self.getstate())
  159.  
  160.     
  161.     def randrange(self, start, stop = None, step = 1, int = int, default = None, maxwidth = 0x1L << BPF):
  162.         """Choose a random item from range(start, stop[, step]).
  163.  
  164.         This fixes the problem with randint() which includes the
  165.         endpoint; in Python this is usually not what you want.
  166.         Do not supply the 'int', 'default', and 'maxwidth' arguments.
  167.         """
  168.         istart = int(start)
  169.         if istart != start:
  170.             raise ValueError, 'non-integer arg 1 for randrange()'
  171.         
  172.         if stop is default:
  173.             if istart > 0:
  174.                 if istart >= maxwidth:
  175.                     return self._randbelow(istart)
  176.                 
  177.                 return int(self.random() * istart)
  178.             
  179.             raise ValueError, 'empty range for randrange()'
  180.         
  181.         istop = int(stop)
  182.         if istop != stop:
  183.             raise ValueError, 'non-integer stop for randrange()'
  184.         
  185.         width = istop - istart
  186.         if step == 1 and width > 0:
  187.             if width >= maxwidth:
  188.                 return int(istart + self._randbelow(width))
  189.             
  190.             return int(istart + int(self.random() * width))
  191.         
  192.         if step == 1:
  193.             raise ValueError, 'empty range for randrange() (%d,%d, %d)' % (istart, istop, width)
  194.         
  195.         istep = int(step)
  196.         if istep != step:
  197.             raise ValueError, 'non-integer step for randrange()'
  198.         
  199.         if istep > 0:
  200.             n = (width + istep - 1) // istep
  201.         elif istep < 0:
  202.             n = (width + istep + 1) // istep
  203.         else:
  204.             raise ValueError, 'zero step for randrange()'
  205.         if n <= 0:
  206.             raise ValueError, 'empty range for randrange()'
  207.         
  208.         if n >= maxwidth:
  209.             return istart + self._randbelow(n)
  210.         
  211.         return istart + istep * int(self.random() * n)
  212.  
  213.     
  214.     def randint(self, a, b):
  215.         '''Return random integer in range [a, b], including both end points.
  216.         '''
  217.         return self.randrange(a, b + 1)
  218.  
  219.     
  220.     def _randbelow(self, n, _log = _log, int = int, _maxwidth = 0x1L << BPF, _Method = _MethodType, _BuiltinMethod = _BuiltinMethodType):
  221.         '''Return a random int in the range [0,n)
  222.  
  223.         Handles the case where n has more bits than returned
  224.         by a single call to the underlying generator.
  225.         '''
  226.         
  227.         try:
  228.             getrandbits = self.getrandbits
  229.         except AttributeError:
  230.             pass
  231.  
  232.         if type(self.random) is _BuiltinMethod or type(getrandbits) is _Method:
  233.             k = int(1.0000100000000001 + _log(n - 1, 2.0))
  234.             r = getrandbits(k)
  235.             while r >= n:
  236.                 r = getrandbits(k)
  237.             return r
  238.         
  239.         if n >= _maxwidth:
  240.             _warn('Underlying random() generator does not supply \nenough bits to choose from a population range this large')
  241.         
  242.         return int(self.random() * n)
  243.  
  244.     
  245.     def choice(self, seq):
  246.         '''Choose a random element from a non-empty sequence.'''
  247.         return seq[int(self.random() * len(seq))]
  248.  
  249.     
  250.     def shuffle(self, x, random = None, int = int):
  251.         '''x, random=random.random -> shuffle list x in place; return None.
  252.  
  253.         Optional arg random is a 0-argument function returning a random
  254.         float in [0.0, 1.0); by default, the standard random.random.
  255.  
  256.         Note that for even rather small len(x), the total number of
  257.         permutations of x is larger than the period of most random number
  258.         generators; this implies that "most" permutations of a long
  259.         sequence can never be generated.
  260.         '''
  261.         if random is None:
  262.             random = self.random
  263.         
  264.         for i in reversed(xrange(1, len(x))):
  265.             j = int(random() * (i + 1))
  266.             x[i] = x[j]
  267.             x[j] = x[i]
  268.         
  269.  
  270.     
  271.     def sample(self, population, k):
  272.         '''Chooses k unique random elements from a population sequence.
  273.  
  274.         Returns a new list containing elements from the population while
  275.         leaving the original population unchanged.  The resulting list is
  276.         in selection order so that all sub-slices will also be valid random
  277.         samples.  This allows raffle winners (the sample) to be partitioned
  278.         into grand prize and second place winners (the subslices).
  279.  
  280.         Members of the population need not be hashable or unique.  If the
  281.         population contains repeats, then each occurrence is a possible
  282.         selection in the sample.
  283.  
  284.         To choose a sample in a range of integers, use xrange as an argument.
  285.         This is especially fast and space efficient for sampling from a
  286.         large population:   sample(xrange(10000000), 60)
  287.         '''
  288.         n = len(population)
  289.         if k <= k:
  290.             pass
  291.         elif not k <= n:
  292.             raise ValueError, 'sample larger than population'
  293.         
  294.         random = self.random
  295.         _int = int
  296.         result = [
  297.             None] * k
  298.         if n < 6 * k:
  299.             pool = list(population)
  300.             for i in xrange(k):
  301.                 j = _int(random() * (n - i))
  302.                 result[i] = pool[j]
  303.                 pool[j] = pool[n - i - 1]
  304.             
  305.         else:
  306.             
  307.             try:
  308.                 if n > 0:
  309.                     pass
  310.                 (population[0], population[n // 2], population[n - 1])
  311.             except (TypeError, KeyError):
  312.                 population = tuple(population)
  313.  
  314.             selected = { }
  315.             for i in xrange(k):
  316.                 j = _int(random() * n)
  317.                 while j in selected:
  318.                     j = _int(random() * n)
  319.                 result[i] = selected[j] = population[j]
  320.             
  321.         return result
  322.  
  323.     
  324.     def uniform(self, a, b):
  325.         '''Get a random number in the range [a, b).'''
  326.         return a + (b - a) * self.random()
  327.  
  328.     
  329.     def normalvariate(self, mu, sigma):
  330.         '''Normal distribution.
  331.  
  332.         mu is the mean, and sigma is the standard deviation.
  333.  
  334.         '''
  335.         random = self.random
  336.         while None:
  337.             u1 = random()
  338.             u2 = 1.0 - random()
  339.             z = NV_MAGICCONST * (u1 - 0.5) / u2
  340.             zz = z * z / 4.0
  341.             if zz <= -_log(u2):
  342.                 break
  343.                 continue
  344.         return mu + z * sigma
  345.  
  346.     
  347.     def lognormvariate(self, mu, sigma):
  348.         """Log normal distribution.
  349.  
  350.         If you take the natural logarithm of this distribution, you'll get a
  351.         normal distribution with mean mu and standard deviation sigma.
  352.         mu can have any value, and sigma must be greater than zero.
  353.  
  354.         """
  355.         return _exp(self.normalvariate(mu, sigma))
  356.  
  357.     
  358.     def expovariate(self, lambd):
  359.         '''Exponential distribution.
  360.  
  361.         lambd is 1.0 divided by the desired mean.  (The parameter would be
  362.         called "lambda", but that is a reserved word in Python.)  Returned
  363.         values range from 0 to positive infinity.
  364.  
  365.         '''
  366.         random = self.random
  367.         u = random()
  368.         while u <= 9.9999999999999995e-08:
  369.             u = random()
  370.         return -_log(u) / lambd
  371.  
  372.     
  373.     def vonmisesvariate(self, mu, kappa):
  374.         '''Circular data distribution.
  375.  
  376.         mu is the mean angle, expressed in radians between 0 and 2*pi, and
  377.         kappa is the concentration parameter, which must be greater than or
  378.         equal to zero.  If kappa is equal to zero, this distribution reduces
  379.         to a uniform random angle over the range 0 to 2*pi.
  380.  
  381.         '''
  382.         random = self.random
  383.         if kappa <= 9.9999999999999995e-07:
  384.             return TWOPI * random()
  385.         
  386.         a = 1.0 + _sqrt(1.0 + 4.0 * kappa * kappa)
  387.         b = (a - _sqrt(2.0 * a)) / 2.0 * kappa
  388.         r = (1.0 + b * b) / 2.0 * b
  389.         while None:
  390.             u1 = random()
  391.             z = _cos(_pi * u1)
  392.             f = (1.0 + r * z) / (r + z)
  393.             c = kappa * (r - f)
  394.             u2 = random()
  395.             if u2 < c * (2.0 - c) or u2 <= c * _exp(1.0 - c):
  396.                 break
  397.                 continue
  398.         u3 = random()
  399.         if u3 > 0.5:
  400.             theta = mu % TWOPI + _acos(f)
  401.         else:
  402.             theta = mu % TWOPI - _acos(f)
  403.         return theta
  404.  
  405.     
  406.     def gammavariate(self, alpha, beta):
  407.         '''Gamma distribution.  Not the gamma function!
  408.  
  409.         Conditions on the parameters are alpha > 0 and beta > 0.
  410.  
  411.         '''
  412.         if alpha <= 0.0 or beta <= 0.0:
  413.             raise ValueError, 'gammavariate: alpha and beta must be > 0.0'
  414.         
  415.         random = self.random
  416.         if alpha > 1.0:
  417.             ainv = _sqrt(2.0 * alpha - 1.0)
  418.             bbb = alpha - LOG4
  419.             ccc = alpha + ainv
  420.             while None:
  421.                 u1 = random()
  422.                 if u1 < u1:
  423.                     pass
  424.                 elif not u1 < 0.99999990000000005:
  425.                     continue
  426.                 
  427.                 u2 = 1.0 - random()
  428.                 v = _log(u1 / (1.0 - u1)) / ainv
  429.                 x = alpha * _exp(v)
  430.                 z = u1 * u1 * u2
  431.                 r = bbb + ccc * v - x
  432.                 if r + SG_MAGICCONST - 4.5 * z >= 0.0 or r >= _log(z):
  433.                     return x * beta
  434.                     continue
  435.         elif alpha == 1.0:
  436.             u = random()
  437.             while u <= 9.9999999999999995e-08:
  438.                 u = random()
  439.             return -_log(u) * beta
  440.         else:
  441.             while None:
  442.                 u = random()
  443.                 b = (_e + alpha) / _e
  444.                 p = b * u
  445.                 if p <= 1.0:
  446.                     x = p ** (1.0 / alpha)
  447.                 else:
  448.                     x = -_log((b - p) / alpha)
  449.                 u1 = random()
  450.                 if p > 1.0:
  451.                     if u1 <= x ** (alpha - 1.0):
  452.                         break
  453.                     
  454.                 if u1 <= _exp(-x):
  455.                     break
  456.                     continue
  457.             return x * beta
  458.  
  459.     
  460.     def gauss(self, mu, sigma):
  461.         '''Gaussian distribution.
  462.  
  463.         mu is the mean, and sigma is the standard deviation.  This is
  464.         slightly faster than the normalvariate() function.
  465.  
  466.         Not thread-safe without a lock around calls.
  467.  
  468.         '''
  469.         random = self.random
  470.         z = self.gauss_next
  471.         self.gauss_next = None
  472.         if z is None:
  473.             x2pi = random() * TWOPI
  474.             g2rad = _sqrt(-2.0 * _log(1.0 - random()))
  475.             z = _cos(x2pi) * g2rad
  476.             self.gauss_next = _sin(x2pi) * g2rad
  477.         
  478.         return mu + z * sigma
  479.  
  480.     
  481.     def betavariate(self, alpha, beta):
  482.         '''Beta distribution.
  483.  
  484.         Conditions on the parameters are alpha > -1 and beta} > -1.
  485.         Returned values range between 0 and 1.
  486.  
  487.         '''
  488.         y = self.gammavariate(alpha, 1.0)
  489.         if y == 0:
  490.             return 0.0
  491.         else:
  492.             return y / (y + self.gammavariate(beta, 1.0))
  493.  
  494.     
  495.     def paretovariate(self, alpha):
  496.         '''Pareto distribution.  alpha is the shape parameter.'''
  497.         u = 1.0 - self.random()
  498.         return 1.0 / pow(u, 1.0 / alpha)
  499.  
  500.     
  501.     def weibullvariate(self, alpha, beta):
  502.         '''Weibull distribution.
  503.  
  504.         alpha is the scale parameter and beta is the shape parameter.
  505.  
  506.         '''
  507.         u = 1.0 - self.random()
  508.         return alpha * pow(-_log(u), 1.0 / beta)
  509.  
  510.  
  511.  
  512. class WichmannHill(Random):
  513.     VERSION = 1
  514.     
  515.     def seed(self, a = None):
  516.         '''Initialize internal state from hashable object.
  517.  
  518.         None or no argument seeds from current time or from an operating
  519.         system specific randomness source if available.
  520.  
  521.         If a is not None or an int or long, hash(a) is used instead.
  522.  
  523.         If a is an int or long, a is used directly.  Distinct values between
  524.         0 and 27814431486575L inclusive are guaranteed to yield distinct
  525.         internal states (this guarantee is specific to the default
  526.         Wichmann-Hill generator).
  527.         '''
  528.         if a is None:
  529.             
  530.             try:
  531.                 a = long(_hexlify(_urandom(16)), 16)
  532.             except NotImplementedError:
  533.                 import time
  534.                 a = long(time.time() * 256)
  535.             except:
  536.                 None<EXCEPTION MATCH>NotImplementedError
  537.             
  538.  
  539.         None<EXCEPTION MATCH>NotImplementedError
  540.         if not isinstance(a, (int, long)):
  541.             a = hash(a)
  542.         
  543.         (a, x) = divmod(a, 30268)
  544.         (a, y) = divmod(a, 30306)
  545.         (a, z) = divmod(a, 30322)
  546.         self._seed = (int(x) + 1, int(y) + 1, int(z) + 1)
  547.         self.gauss_next = None
  548.  
  549.     
  550.     def random(self):
  551.         '''Get the next random number in the range [0.0, 1.0).'''
  552.         (x, y, z) = self._seed
  553.         x = 171 * x % 30269
  554.         y = 172 * y % 30307
  555.         z = 170 * z % 30323
  556.         self._seed = (x, y, z)
  557.         return (x / 30269.0 + y / 30307.0 + z / 30323.0) % 1.0
  558.  
  559.     
  560.     def getstate(self):
  561.         '''Return internal state; can be passed to setstate() later.'''
  562.         return (self.VERSION, self._seed, self.gauss_next)
  563.  
  564.     
  565.     def setstate(self, state):
  566.         '''Restore internal state from object returned by getstate().'''
  567.         version = state[0]
  568.         if version == 1:
  569.             (version, self._seed, self.gauss_next) = state
  570.         else:
  571.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  572.  
  573.     
  574.     def jumpahead(self, n):
  575.         '''Act as if n calls to random() were made, but quickly.
  576.  
  577.         n is an int, greater than or equal to 0.
  578.  
  579.         Example use:  If you have 2 threads and know that each will
  580.         consume no more than a million random numbers, create two Random
  581.         objects r1 and r2, then do
  582.             r2.setstate(r1.getstate())
  583.             r2.jumpahead(1000000)
  584.         Then r1 and r2 will use guaranteed-disjoint segments of the full
  585.         period.
  586.         '''
  587.         if not n >= 0:
  588.             raise ValueError('n must be >= 0')
  589.         
  590.         (x, y, z) = self._seed
  591.         x = int(x * pow(171, n, 30269)) % 30269
  592.         y = int(y * pow(172, n, 30307)) % 30307
  593.         z = int(z * pow(170, n, 30323)) % 30323
  594.         self._seed = (x, y, z)
  595.  
  596.     
  597.     def __whseed(self, x = 0, y = 0, z = 0):
  598.         '''Set the Wichmann-Hill seed from (x, y, z).
  599.  
  600.         These must be integers in the range [0, 256).
  601.         '''
  602.         if type(y) == type(y) and type(z) == type(z):
  603.             pass
  604.         elif not type(z) == int:
  605.             raise TypeError('seeds must be integers')
  606.         
  607.         if x == x and y == y:
  608.             pass
  609.         elif y == z:
  610.             import time
  611.             t = long(time.time() * 256)
  612.             t = int(t & 16777215 ^ t >> 24)
  613.             (t, x) = divmod(t, 256)
  614.             (t, y) = divmod(t, 256)
  615.             (t, z) = divmod(t, 256)
  616.         
  617.         if not z:
  618.             pass
  619.         self._seed = (None, 1 if not x else 1, 1)
  620.         self.gauss_next = None
  621.  
  622.     
  623.     def whseed(self, a = None):
  624.         """Seed from hashable object's hash code.
  625.  
  626.         None or no argument seeds from current time.  It is not guaranteed
  627.         that objects with distinct hash codes lead to distinct internal
  628.         states.
  629.  
  630.         This is obsolete, provided for compatibility with the seed routine
  631.         used prior to Python 2.1.  Use the .seed() method instead.
  632.         """
  633.         if a is None:
  634.             self._WichmannHill__whseed()
  635.             return None
  636.         
  637.         a = hash(a)
  638.         (a, x) = divmod(a, 256)
  639.         (a, y) = divmod(a, 256)
  640.         (a, z) = divmod(a, 256)
  641.         if not (x + a) % 256:
  642.             pass
  643.         x = 1
  644.         if not (y + a) % 256:
  645.             pass
  646.         y = 1
  647.         if not (z + a) % 256:
  648.             pass
  649.         z = 1
  650.         self._WichmannHill__whseed(x, y, z)
  651.  
  652.  
  653.  
  654. class SystemRandom(Random):
  655.     '''Alternate random number generator using sources provided
  656.     by the operating system (such as /dev/urandom on Unix or
  657.     CryptGenRandom on Windows).
  658.  
  659.      Not available on all systems (see os.urandom() for details).
  660.     '''
  661.     
  662.     def random(self):
  663.         '''Get the next random number in the range [0.0, 1.0).'''
  664.         return (long(_hexlify(_urandom(7)), 16) >> 3) * RECIP_BPF
  665.  
  666.     
  667.     def getrandbits(self, k):
  668.         '''getrandbits(k) -> x.  Generates a long int with k random bits.'''
  669.         if k <= 0:
  670.             raise ValueError('number of bits must be greater than zero')
  671.         
  672.         if k != int(k):
  673.             raise TypeError('number of bits should be an integer')
  674.         
  675.         bytes = (k + 7) // 8
  676.         x = long(_hexlify(_urandom(bytes)), 16)
  677.         return x >> bytes * 8 - k
  678.  
  679.     
  680.     def _stub(self, *args, **kwds):
  681.         '''Stub method.  Not used for a system random number generator.'''
  682.         pass
  683.  
  684.     seed = jumpahead = _stub
  685.     
  686.     def _notimplemented(self, *args, **kwds):
  687.         '''Method should not be called for a system random number generator.'''
  688.         raise NotImplementedError('System entropy source does not have state.')
  689.  
  690.     getstate = setstate = _notimplemented
  691.  
  692.  
  693. def _test_generator(n, func, args):
  694.     import time
  695.     print n, 'times', func.__name__
  696.     total = 0.0
  697.     sqsum = 0.0
  698.     smallest = 10000000000.0
  699.     largest = -10000000000.0
  700.     t0 = time.time()
  701.     for i in range(n):
  702.         x = func(*args)
  703.         total += x
  704.         sqsum = sqsum + x * x
  705.         smallest = min(x, smallest)
  706.         largest = max(x, largest)
  707.     
  708.     t1 = time.time()
  709.     print round(t1 - t0, 3), 'sec,',
  710.     avg = total / n
  711.     stddev = _sqrt(sqsum / n - avg * avg)
  712.     print 'avg %g, stddev %g, min %g, max %g' % (avg, stddev, smallest, largest)
  713.  
  714.  
  715. def _test(N = 2000):
  716.     _test_generator(N, random, ())
  717.     _test_generator(N, normalvariate, (0.0, 1.0))
  718.     _test_generator(N, lognormvariate, (0.0, 1.0))
  719.     _test_generator(N, vonmisesvariate, (0.0, 1.0))
  720.     _test_generator(N, gammavariate, (0.01, 1.0))
  721.     _test_generator(N, gammavariate, (0.10000000000000001, 1.0))
  722.     _test_generator(N, gammavariate, (0.10000000000000001, 2.0))
  723.     _test_generator(N, gammavariate, (0.5, 1.0))
  724.     _test_generator(N, gammavariate, (0.90000000000000002, 1.0))
  725.     _test_generator(N, gammavariate, (1.0, 1.0))
  726.     _test_generator(N, gammavariate, (2.0, 1.0))
  727.     _test_generator(N, gammavariate, (20.0, 1.0))
  728.     _test_generator(N, gammavariate, (200.0, 1.0))
  729.     _test_generator(N, gauss, (0.0, 1.0))
  730.     _test_generator(N, betavariate, (3.0, 3.0))
  731.  
  732. _inst = Random()
  733. seed = _inst.seed
  734. random = _inst.random
  735. uniform = _inst.uniform
  736. randint = _inst.randint
  737. choice = _inst.choice
  738. randrange = _inst.randrange
  739. sample = _inst.sample
  740. shuffle = _inst.shuffle
  741. normalvariate = _inst.normalvariate
  742. lognormvariate = _inst.lognormvariate
  743. expovariate = _inst.expovariate
  744. vonmisesvariate = _inst.vonmisesvariate
  745. gammavariate = _inst.gammavariate
  746. gauss = _inst.gauss
  747. betavariate = _inst.betavariate
  748. paretovariate = _inst.paretovariate
  749. weibullvariate = _inst.weibullvariate
  750. getstate = _inst.getstate
  751. setstate = _inst.setstate
  752. jumpahead = _inst.jumpahead
  753. getrandbits = _inst.getrandbits
  754. if __name__ == '__main__':
  755.     _test()
  756.  
  757.